{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "import glob\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
    "import torch.nn.functional as F\n",
    "from collections import defaultdict\n",
    "import copy\n",
    "import sys\n",
    "from scipy import ndimage\n",
    "cmap=plt.cm.Spectral_r\n",
    "from mpl_toolkits import mplot3d\n",
    "from pathlib import Path\n",
    "from utils import get_data\n",
    "from main import test\n",
    "from models import FullyConnected\n",
    "import string\n",
    "\n",
    "sys.path.append('.')\n",
    "plt.rcParams.update(plt.rcParamsDefault)\n",
    "plt.rcParams.update({\n",
    "    #\"text.usetex\": True,\n",
    "    \"font.family\": \"serif\",\n",
    "    'font.size':12,\n",
    "    \"lines.linewidth\":3.0,\n",
    "    \"savefig.dpi\":500\n",
    "})\n",
    "cmap = plt.get_cmap('Spectral_r')\n",
    "\n",
    "savedir= './figs/'.format(**params)\n",
    "if not os.path.exists(savedir):\n",
    "    os.mkdir(savedir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helpers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find(array, value):\n",
    "    idx= np.argwhere(np.array(array)==value)[0,0]\n",
    "    return idx\n",
    "\n",
    "def h2p(width, input_size, depth):\n",
    "    return input_size*width + (depth-1) * width**2 + width\n",
    "h2p = np.vectorize(h2p)\n",
    "\n",
    "def select_runs(runs, params, constraints):\n",
    "    selected_runs = []\n",
    "    for irun, run in enumerate(runs):\n",
    "        keep = True\n",
    "        for k,v in constraints.items():\n",
    "            if getattr(run['args'],k) != v:\n",
    "                keep = False\n",
    "                break\n",
    "        if keep:\n",
    "            selected_runs.append(run)\n",
    "    selected_params = copy.deepcopy(params)\n",
    "    for con in constraints:\n",
    "        selected_params[con]=[constraints[con]]\n",
    "    return selected_runs, selected_params\n",
    "\n",
    "def group_runs(runs, finished_only=True):\n",
    "    runs_grouped = defaultdict(list)\n",
    "    for run in runs:\n",
    "        seedless_args = copy.deepcopy(run['args'])\n",
    "        del(seedless_args.seed)\n",
    "        del(seedless_args.name)\n",
    "        if str(seedless_args) not in runs_grouped.keys(): \n",
    "            runs_grouped[str(seedless_args)].append(run) # need at least one run\n",
    "        else:\n",
    "            if run['finished'] or not finished_only:\n",
    "                runs_grouped[str(seedless_args)].append(run)\n",
    "    runs_grouped = list(runs_grouped.values())\n",
    "    return runs_grouped\n",
    "\n",
    "def flatten(weights):\n",
    "    return torch.cat([w.view(-1) for w in weights.values()])\n",
    "\n",
    "def interpolate(w1, w2, alpha):\n",
    "    w3 = copy.deepcopy(w1)\n",
    "    for (k1,p1), (k2,p2) in zip(w1.items(), w2.items()):\n",
    "        w3[k1] = alpha * p1 + (1-alpha) * p2\n",
    "    return w3\n",
    "\n",
    "def last_non_nan(array):\n",
    "    return (~np.isnan(array)).cumsum(1).argmax(1)\n",
    "\n",
    "def calc_ens_acc(group, test_loader):\n",
    "    args = group[0]['args']\n",
    "    x,y = list(test_loader)[0]\n",
    "    for run in group:\n",
    "        model = FullyConnected(input_size = input_channels * input_size**2,\n",
    "                       output_size=output_size, hidden_size=args.hidden_size, n_layers=args.n_layers,\n",
    "                       training_method=args.training_method, activation=args.activation, \n",
    "                       feedback_init=args.feedback_init, weight_init = args.weight_init)\n",
    "        model.load_state_dict(run['weights'])\n",
    "        outs.append(model(x))\n",
    "    y_pred = torch.stack(outs).mean(dim=0).max(1)[1]\n",
    "    ens_acc = y_pred.eq(y).sum().float()/len(y)*100\n",
    "    return ens_acc\n",
    "\n",
    "def calc_weight_alignments(group):\n",
    "    if not isinstance(group,list):\n",
    "        group = [group]\n",
    "    args = group[0]['args']\n",
    "    alignments = {l:[] for l in range(1,args.n_layers)}\n",
    "    for run in group:  \n",
    "        b = run['feedback_matrix']\n",
    "        if type(run['weights'])==list: weights = run['weights'][-1]\n",
    "        else: weights = run['weights']\n",
    "        for l in range(1,args.n_layers):\n",
    "            w = weights['layers.{}.weight'.format(l)].view(-1)\n",
    "            if l == args.n_layers-1:\n",
    "                v = b[-1].view(-1)\n",
    "            else:\n",
    "                v = (b[l].t()@b[l-1]).view(-1)\n",
    "            a = w @ v / w.norm() / v.norm()\n",
    "            if np.isnan(a):\n",
    "                print('nan ', end=' ')\n",
    "                continue\n",
    "            alignments[l].append(a)\n",
    "    return alignments\n",
    "\n",
    "def calc_time_angles(group):\n",
    "\n",
    "    angles = []\n",
    "    for t in range(len(group[0]['weights'])):\n",
    "        angles_tmp = []\n",
    "        weights = []\n",
    "        for run in group:\n",
    "            try: weights.append(run['weights'][t])\n",
    "            except: continue\n",
    "        for i1, w1 in enumerate(weights):\n",
    "            for i2, w2 in enumerate(weights):\n",
    "                if i1<=i2: continue\n",
    "                angle = flatten(w1)@flatten(w2).t()/flatten(w1).norm()/flatten(w2).norm()\n",
    "                if not np.isnan(angle):\n",
    "                    angles_tmp.append(angle.item())\n",
    "        angles.append(angles_tmp)\n",
    "    return angles\n",
    "\n",
    "def calc_final_angles(group):\n",
    "\n",
    "    weights = []\n",
    "    angles = defaultdict(list)\n",
    "    for run in group:\n",
    "        if type(run['weights'])==list: \n",
    "            weights.append(run['weights'][-1])\n",
    "        else: \n",
    "            weights.append(run['weights'])\n",
    "    for i1, w1 in enumerate(weights):\n",
    "        for i2, w2 in enumerate(weights):\n",
    "            if i1<=i2: continue\n",
    "            angle = flatten(w1)@flatten(w2).t()/flatten(w1).norm()/flatten(w2).norm()\n",
    "            if not np.isnan(angle):\n",
    "                angles['total'].append(angle.item())\n",
    "            for l, (p1, p2) in enumerate(zip(w1.values(), w2.values())):\n",
    "                angle = p1.view(-1) @ p2.view(-1).t()/p1.norm()/p2.norm().item()\n",
    "                if not np.isnan(angle):\n",
    "                    angles[l].append(angle.item())\n",
    "    return angles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load runs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "r.1601980811/\n",
      "seed range(0, 10)\n",
      "label_noise [0.0]\n",
      "hidden_size [100]\n",
      "n_layers [3]\n",
      "activation ['linear', 'tanh', 'relu']\n",
      "dataset ['RANDOM']\n",
      "epochs [10000]\n",
      "log_every [100]\n",
      "training_method ['DFA']\n",
      "feedback_init ['UNIFORM']\n",
      "weight_init ['UNIFORM']\n",
      "learning_rate [0.0001]\n",
      "momentum [0.0]\n",
      "batch_size [32]\n",
      "test_batch_size [1000]\n",
      "model ['fc']\n",
      "no_gpu [True]\n",
      "dataset_path ['~/data']\n",
      "datasize [1000]\n",
      "num_classes [2]\n",
      "input_dim [16]\n",
      "optimizer ['SGD']\n",
      "task ['REGRESSION']\n",
      "alpha [0.2, 0.4, 0.6, 0.8, 1.0]\n",
      "beta [0.2, 0.4, 0.6, 0.8, 1.0]\n",
      "0 out of 113\n",
      "28 out of 113\n",
      "56 out of 113\n",
      "84 out of 113\n",
      "112 out of 113\n"
     ]
    }
   ],
   "source": [
    "paths = sorted(glob.glob('r.*'), key=os.path.getmtime)\n",
    "last = paths[-1]\n",
    "path+='/'\n",
    "print(path)\n",
    "\n",
    "def load_runs(path):\n",
    "\n",
    "    runs = []\n",
    "    params = torch.load(path+'params.pkl')\n",
    "    for k, v in params.items():\n",
    "        print(k,v)\n",
    "    files = glob.glob(path + '*.pyT')\n",
    "    for ifile, file in enumerate(files):\n",
    "        if ifile%(len(files)//4)==0:\n",
    "            print(ifile, 'out of', len(files))\n",
    "        try:\n",
    "            run = torch.load(file)\n",
    "        except:\n",
    "            continue\n",
    "        torch.save(run, file)\n",
    "        runs.append(run)\n",
    "\n",
    "    return runs, params\n",
    "\n",
    "runs, params = get_runs(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dynamics at fixed width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'r.1601840497/' # path to folder generated by submit_width.py\n",
    "runs, params = load_runs(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "colors = {'MNIST relu':'C0', 'MNIST tanh':'C1', 'CIFAR10 relu':'C2', 'CIFAR10 tanh':'C3'}\n",
    "\n",
    "def calc_time_angles(group):\n",
    "\n",
    "    angles = []\n",
    "    for t in range(len(group[0]['weights'])):\n",
    "        angles_tmp = []\n",
    "        weights = []\n",
    "        for run in group:\n",
    "            try: weights.append(run['weights'][t])\n",
    "            except: continue\n",
    "        for i1, w1 in enumerate(weights):\n",
    "            for i2, w2 in enumerate(weights):\n",
    "                if i1<=i2: continue\n",
    "                angle = flatten(w1)@flatten(w2).t()/flatten(w1).norm()/flatten(w2).norm()\n",
    "                if not np.isnan(angle):\n",
    "                    angles_tmp.append(angle.item())\n",
    "        angles.append(angles_tmp)\n",
    "    return angles\n",
    "\n",
    "grouped_runs = group_runs(runs, finished_only=True)\n",
    "\n",
    "angle_dict = {}\n",
    "train_acc_dict = {}\n",
    "wa_dict = {}\n",
    "ga_dict = {}\n",
    "\n",
    "for igroup, group in enumerate(grouped_runs):\n",
    "    print(igroup, 'out of', len(grouped_runs))\n",
    "    args = group[0]['args']\n",
    "    key  =(args.dataset, args.activation, args.training_method)\n",
    "    ls   = '-' if args.training_method == 'DFA' else ':'\n",
    "\n",
    "    train_acc_dict[key] = np.mean(np.array([run['train_accs'] for run in group]), axis=0)\n",
    "    if args.training_method == 'DFA':\n",
    "        wa_dict[key] = np.mean(np.array([run['weight_alignments']['total'] for run in group]), axis=0)\n",
    "        ga_dict[key] = np.mean(np.array([run['grad_alignments']  ['total'] for run in group]), axis=0)\n",
    "    \n",
    "    angles = calc_final_angles(group)['total']\n",
    "    angles_history = calc_time_angles(group)\n",
    "    epochs1 = np.array(range(len(angles_history)))*args.save_every+1\n",
    "    angle_dict[key] = [np.nanmean(angles) for angles in angles_history]\n",
    "    epochs2 = np.linspace(0, max(epochs1), len(train_acc))+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
    "fig, axarr = plt.subplots(1,4, figsize=(12,3))\n",
    "\n",
    "for key in angle_dict.keys():\n",
    "    label = '{} {}'.format(key[0], key[1])\n",
    "    color= colors[label]\n",
    "    ls = '-' if key[2] == 'DFA' else ':'\n",
    "    axarr[0].plot(epochs2, 100-train_acc_dict[key], color=color, ls=ls)\n",
    "    if key[2]=='DFA':\n",
    "        axarr[1].plot(epochs2, wa_dict[key], color=color, ls=ls)\n",
    "        axarr[2].plot(epochs2, ga_dict[key], color=color, ls=ls)    \n",
    "        axarr[3].plot(epochs1, angle_dict[key], label=(label if key[2]=='DFA' else ''), color=color, ls=ls)\n",
    "    else: \n",
    "        axarr[3].plot(epochs1, angle_dict[key], color=color, ls=ls)\n",
    "\n",
    "axarr[3].plot([],[],color='k', lw=1, label='DFA')\n",
    "axarr[3].plot([],[],color='k', ls=':', lw=1, label='BP')\n",
    "axarr[3].legend(bbox_to_anchor=(1.1,.9))\n",
    "\n",
    "for i, ax in enumerate(axarr):\n",
    "    ax.set_xscale('log')\n",
    "    ax.set_xlabel('Epochs')\n",
    "    ax.text(-0.1, 1.1, string.ascii_uppercase[i], transform=ax.transAxes, size=20, weight='bold')\n",
    "axarr[3].set_yscale('log')\n",
    "\n",
    "axarr[0].set_ylabel('Train error')\n",
    "axarr[1].set_ylabel('Weight alignment')\n",
    "axarr[2].set_ylabel('Gradient alignment')\n",
    "axarr[3].set_ylabel('Cosine similarity')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(savedir+'Dynamics_angle.pdf', bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Varying label noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'r.1601976778/' # path to folder generated by submit_noise.py\n",
    "runs, params = load_runs(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_key = 'label_noise'\n",
    "legend_key = 'p'\n",
    "x = params[label_key]\n",
    "\n",
    "for dataset in ['MNIST','CIFAR10']:\n",
    "    for activation in ['relu', 'tanh', 'linear']:\n",
    "\n",
    "        constraints = {'dataset' : dataset,\n",
    "                      'activation' : activation,}\n",
    "        \n",
    "        selected_runs, _ = select_runs(runs, params, constraints)\n",
    "        grouped_runs = group_runs(selected_runs, finished_only=True)\n",
    "\n",
    "        fig, axarr = plt.subplots(1,2, figsize=(7,3))\n",
    "        axins = inset_axes(axarr[1], width='40%', height='40%', loc=2)\n",
    "        \n",
    "        n_steps = len(runs[0]['test_loss'])\n",
    "        for group in grouped_runs:\n",
    "            args = group[0]['args']\n",
    "            i = find(x,getattr(args, label_key))\n",
    "            train_acc = np.mean([run['train_accs']  for run in group], axis=0)\n",
    "            test_acc = np.mean([run['test_accs']  for run in group], axis=0)\n",
    "            wa = np.mean([run['weight_alignments']['total'] for run in group], axis=0)\n",
    "            ga = np.mean([run['grad_alignments']['total'] for run in group], axis=0)\n",
    "            t = np.array(range(1,len(train_acc)+1))*args.log_every*args.batch_size/60000\n",
    "            label=getattr(args, label_key)\n",
    "            color=cmap(i/len(x))\n",
    "            axarr[0].semilogx(t, 100-train_acc, color=color, label=label)\n",
    "            axarr[1].semilogx(t, ga,           color=color, label=label)\n",
    "            axins.semilogx(t, wa,           color=color, label=label)\n",
    "        handles, labels = axarr[0].get_legend_handles_labels()\n",
    "        handles, labels = zip(*[ (handles[i], labels[i]) for i in sorted(range(len(handles)), key=lambda k: list(map(float,labels))[k])] )\n",
    "        labels = ['{}={}'.format(legend_key, label) for label in labels]\n",
    "        axarr[0].legend(handles, labels)\n",
    "        for ax in axarr: \n",
    "            ax.set_xlabel('Epochs')\n",
    "        axarr[0].set_ylabel('Train error')\n",
    "        axarr[1].set_ylabel('Gradient alignment')\n",
    "        axins.text(.5,-.2,'Weight align', horizontalalignment='center',transform=axins.transAxes, fontsize=10)\n",
    "        axins.set_xticks([])\n",
    "        axins.set_yticks([])\n",
    "\n",
    "        plt.tight_layout()\n",
    "        plt.savefig(savedir+'Noise_dynamics_{}_{}.pdf'.format(args.dataset, args.activation), bbox_inches='tight')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Alpha Beta experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'r.1601983411/' # path to folder generated by submit_alphabeta.py\n",
    "runs, params = load_runs(path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x300 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 900x300 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "key1 = 'beta'\n",
    "key2 = 'alpha'\n",
    "new_params = copy.deepcopy(params)\n",
    "new_params[key1]=params[key1][::2]\n",
    "\n",
    "for dataset in ['RANDOM']:\n",
    "    for activation in ['tanh', 'relu']:\n",
    "\n",
    "        constraints = {'dataset' : dataset,\n",
    "                      'activation' : activation}\n",
    "        \n",
    "        selected_runs, _ = select_runs(runs, new_params, constraints)\n",
    "        grouped_runs = group_runs(selected_runs, finished_only=True)\n",
    "\n",
    "        fig, axarr = plt.subplots(1, len(new_params[key1]), figsize=(3*len(new_params[key1]),3), sharey=True)\n",
    "        n_steps = len(runs[0]['test_loss'])\n",
    "        for group in sorted(grouped_runs, key=lambda x:getattr(x[0]['args'],key1)):\n",
    "            args = group[0]['args']\n",
    "            if getattr(args,key1) not in new_params[key1]: continue\n",
    "            i = find(new_params[key1], getattr(args, key1))\n",
    "            j = find(new_params[key2], getattr(args, key2))\n",
    "            wa = np.mean([run['weight_alignments']['total'] for run in group], axis=0)\n",
    "            ga = np.mean([run['grad_alignments']['total'] for run in group], axis=0)\n",
    "            tr = np.mean([run['train_loss'] for run in group], axis=0)\n",
    "            te = np.mean([run['test_loss'] for run in group], axis=0)\n",
    "            t = np.array(range(1,len(wa)+1))*args.log_every*args.batch_size/args.datasize\n",
    "            label=getattr(args, key2)\n",
    "            color=cmap(j/len(new_params[key2]))\n",
    "            axarr[i].semilogx(t, wa, color=color, label=label)\n",
    "        handles, labels = axarr[-1].get_legend_handles_labels()\n",
    "        handles, labels = zip(*[ (handles[i], labels[i]) for i in sorted(range(len(handles)), key=lambda k: list(map(float,labels))[k])] )\n",
    "        labels = [r'$\\alpha = {}$'.format(label) for label in labels]\n",
    "        axarr[-1].legend(handles, labels, bbox_to_anchor=(1.1,.9))\n",
    "\n",
    "        for i, ax in enumerate(axarr): \n",
    "            ax.set_xlabel('Epochs')\n",
    "            ax.set_title(r'$\\beta = {}$'.format(new_params[key1][i]))\n",
    "            #ax.set_ylim(bottom=0, top=1)\n",
    "        axarr[0].set_ylabel('Weight alignment')\n",
    "\n",
    "        #plt.suptitle('{} {}'.format(args.dataset, args.activation))\n",
    "        plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
    "        plt.savefig(savedir+'alphabeta_dynamics_{}.pdf'.format(args.activation), bbox_inches='tight')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x400 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "key1 = 'beta'\n",
    "key2 = 'alpha'\n",
    "\n",
    "for dataset in ['RANDOM']:\n",
    "    for activation in ['relu', 'tanh']:\n",
    "\n",
    "        constraints = {'dataset' : dataset,\n",
    "                      'activation' : activation}\n",
    "        \n",
    "        selected_runs, _ = select_runs(runs, params, constraints)\n",
    "        grouped_runs = group_runs(selected_runs, finished_only=True)\n",
    "\n",
    "        fig, ax = plt.subplots(1, figsize=(5,4))      \n",
    "        axins = inset_axes(ax, width='40%', height='40%', loc=4, bbox_to_anchor=(0.1, 0.05, .85, 1), bbox_transform=ax.transAxes)\n",
    "        grid_ga = np.zeros((len(params[key1]),len(params[key2])))\n",
    "        grid_wa = np.zeros((len(params[key1]),len(params[key2])))\n",
    "        grid_tl = np.zeros((len(params[key1]),len(params[key2])))\n",
    "\n",
    "        for group in grouped_runs:\n",
    "            args = group[0]['args']\n",
    "            i,j = find(params[key1], getattr(args, key1)), find(params[key2], getattr(args, key2))\n",
    "            grid_tl[i,j] = np.mean([run['train_loss'                ][-1] for run in group])\n",
    "            grid_ga[i,j] = np.mean([run['grad_alignments']  ['total'][-1] for run in group])\n",
    "            grid_wa[i,j] = np.mean([run['weight_alignments']['total'][-1] for run in group])\n",
    "        im1 = ax.imshow( grid_ga, origin='lower', )\n",
    "        axins.   imshow( grid_wa, origin='lower', )\n",
    "        plt.colorbar(im1, ax=ax)\n",
    "        #im2 = axarr[1].contourf(np.array(params[key1]), np.array(params[key2]), grid2)\n",
    "        #plt.colorbar(im2, ax=axarr[1])\n",
    "        \n",
    "        ax.set_title('Gradient alignment')\n",
    "        ax.set_xlabel(r'$\\alpha$',fontsize=20)\n",
    "        ax.set_ylabel(r'$\\beta$' ,fontsize=20)\n",
    "        ax.set_aspect('equal')\n",
    "        ax.set_xticklabels(['']+params[key1])\n",
    "        ax.set_yticklabels(['']+params[key2])        \n",
    "        \n",
    "        axins.set_title('Weight align')\n",
    "        axins.set_xticks([])\n",
    "        axins.set_yticks([])\n",
    "        axins.set_aspect('equal')\n",
    "\n",
    "        plt.savefig(savedir+'alphabeta_{}.pdf'.format(args.activation), bbox_inches='tight')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Varying width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'r.1601590379/' # path to folder generated by submit_width.py\n",
    "runs, params = load_runs(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "save = True\n",
    "plot_key = 'hidden_size'\n",
    "plot_label = 'Width'\n",
    "log = True\n",
    "x_var = params[plot_key]\n",
    "\n",
    "for dataset in ['MNIST','CIFAR10']:\n",
    "        \n",
    "    for activation in ['relu', 'tanh']:\n",
    "\n",
    "        constraints = {'dataset' : dataset,\n",
    "                       'activation' : activation,\n",
    "                       'num_classes' : 10}\n",
    "        selected_runs, params = select_runs(runs, params, constraints)\n",
    "        grouped_runs = group_runs(selected_runs, finished_only=False)\n",
    "\n",
    "        args=grouped_runs[0][0]['args']\n",
    "        train_loader, train_loader_log, test_loader, input_size, output_size, input_channels = get_data(args.dataset, args.dataset_path, args.batch_size, test_batch_size=10000, num_classes=args.num_classes, datasize=None)\n",
    "\n",
    "        best_test_acc   = {'BP':np.zeros((len(x_var),2)), 'DFA':np.zeros((len(x_var),2))}\n",
    "        final_test_acc  = {'BP':np.zeros((len(x_var),2)), 'DFA':np.zeros((len(x_var),2))}\n",
    "        final_ens_acc   = {'BP':np.zeros((len(x_var),2)), 'DFA':np.zeros((len(x_var),2))}\n",
    "        final_train_acc = {'BP':np.zeros((len(x_var),2)), 'DFA':np.zeros((len(x_var),2))}\n",
    "        angle           = {'BP':np.zeros((len(x_var),2)), 'DFA':np.zeros((len(x_var),2))}\n",
    "        grad_overlap = {}\n",
    "        weight_overlap = {}\n",
    "        layerwise_angle = {}\n",
    "        for l in range(runs[0]['args'].n_layers):\n",
    "            grad_overlap[l] = np.zeros((len(x_var),2))\n",
    "            weight_overlap[l] = np.zeros((len(x_var),2))\n",
    "            layerwise_angle[l] = np.zeros((len(x_var),2))\n",
    "\n",
    "        for igroup, group in enumerate(grouped_runs):\n",
    "            args = group[0]['args']\n",
    "            idx = find(params[plot_key],getattr(args, plot_key))\n",
    "            print('width {}: {} seeds, {} finished'.format(x_var[idx], len(group), len([run for run in group if run['finished']])))\n",
    "            \n",
    "            outs = []\n",
    "            ens_acc = 0#calc_ens_acc(group, test_loader)\n",
    "            \n",
    "            best_test_accs=[np.max(run['test_accs']) for run in group]\n",
    "            final_test_accs =  [   run['test_accs'][-1]    for run in group]\n",
    "            final_train_accs =   [run['train_accs'][-1]    for run in group]\n",
    "            best_test_acc[args.training_method][idx]  = [np.mean(best_test_accs),   np.std(best_test_accs)  ]\n",
    "            final_test_acc[args.training_method][idx] = [np.mean(final_test_accs),  np.std(final_test_accs) ]\n",
    "            final_train_acc[args.training_method][idx]= [np.mean(final_train_accs), np.std(final_train_accs)]\n",
    "            final_ens_acc[args.training_method][idx]= ens_acc\n",
    "\n",
    "            angles = calc_final_angles(group)\n",
    "            #if len(angles['total'])==0:\n",
    "                #print(args.name)\n",
    "            angle[args.training_method][idx] = [np.mean(angles['total']), np.std(angles['total'])]\n",
    "\n",
    "            if args.training_method=='DFA':\n",
    "                for l in range(args.n_layers-1):\n",
    "                    grad_overlaps =   [run['grad_alignments'][l][-1]  for run in group]\n",
    "                    weight_overlaps = [run['weight_alignments'][l][-1]  for run in group]\n",
    "                    grad_overlap[l][idx]   = [np.nanmean(grad_overlaps),   np.std(grad_overlaps)  ]\n",
    "                    weight_overlap[l][idx] = [np.nanmean(weight_overlaps), np.std(weight_overlaps)]\n",
    "                for l in range(args.n_layers):\n",
    "                    layerwise_angle[l][idx] = [np.nanmean(angles[l]), np.std(angles[l])]\n",
    "                    \n",
    "        fig, axarr = plt.subplots(1,3,figsize=(12,4))\n",
    "\n",
    "        for i, (k, v) in enumerate(final_train_acc.items()) :\n",
    "            axarr[0].errorbar(x_var, 100-v[:,0], yerr=v[:,1], color='k' if i else 'grey', label=k)\n",
    "        axarr[0].legend()\n",
    "        axarr[0].set_xlabel(plot_key)\n",
    "        axarr[0].set_ylabel('Train error')\n",
    "        axarr[1].set_ylabel('Cosine similarity of weights')\n",
    "        for l in range(args.n_layers):\n",
    "            axarr[1].errorbar(x_var, layerwise_angle[l][:,0], yerr=layerwise_angle[l][:,1], label='layer %d'%(l+1))\n",
    "        axarr[1].errorbar(x_var, angle['BP'][:,0], yerr=angle['BP'][:,1], label='BP', color='grey')\n",
    "        \n",
    "        for l in range(args.n_layers-1):\n",
    "            axarr[2].errorbar(x_var, grad_overlap[l][:,0], yerr=grad_overlap[l][:,1], label='layer %d'%(l+1))\n",
    "        axarr[2].set_ylabel('Gradient alignment')\n",
    "        \n",
    "        for i, ax in enumerate(axarr):\n",
    "            ax.set_xlabel(plot_label)\n",
    "            ax.legend()\n",
    "            ax.text(-0.1, 1.1, string.ascii_uppercase[i], transform=ax.transAxes, size=20, weight='bold')\n",
    "        if log:\n",
    "            for ax in axarr: ax.set_xscale('log')\n",
    "\n",
    "        #plt.suptitle('{} {}'.format(args.dataset, args.activation))\n",
    "        plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
    "        if save: plt.savefig(savedir+'Results_statics_{}_{}.pdf'.format(args.dataset, args.activation), bbox_inches='tight')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dynamics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_key = 'hidden_size'\n",
    "x = params[label_key]\n",
    "\n",
    "for dataset in ['MNIST', 'CIFAR10']:\n",
    "    for activation in ['relu','tanh']:\n",
    "\n",
    "        constraints = {'dataset' : dataset,\n",
    "                   'activation' : activation,\n",
    "                      'num_classes':10}\n",
    "        \n",
    "        selected_runs, _ = select_runs(runs, params, constraints)\n",
    "        grouped_runs = group_runs(selected_runs)\n",
    "\n",
    "        fig, axarr = plt.subplots(1,4, figsize=(14,4))\n",
    "        n_steps = len(runs[0]['test_loss'])\n",
    "        for group in grouped_runs:\n",
    "            args = group[0]['args']\n",
    "            i = find(x,getattr(args, label_key))\n",
    "            try:\n",
    "                train_acc = np.mean([run['train_accs']           for run in group], axis=0)\n",
    "                test_acc  = np.mean([run[ 'test_accs']           for run in group], axis=0)\n",
    "                a1        = np.mean([run['weight_alignments'][2] for run in group], axis=0)\n",
    "                a2        = np.mean([run['grad_alignments'][2]   for run in group], axis=0)            \n",
    "            except:\n",
    "                print('Failed for {} {}'.format(label_key, x[i]))\n",
    "                continue\n",
    "\n",
    "            t = np.array(range(1,len(train_acc)+1))*args.log_every\n",
    "            label=getattr(args, label_key)\n",
    "            color=cmap(i/len(x))\n",
    "            if args.training_method == 'BP':\n",
    "                axarr[0].semilogx(t, 100-train_acc, color=color, label=label)\n",
    "            else :   \n",
    "                axarr[1].semilogx(t, 100-train_acc,color=color, label=label)\n",
    "                axarr[2].semilogx(t, a1,           color=color, label=label)\n",
    "                axarr[3].semilogx(t, a2,           color=color, label=label)\n",
    "        #axarr[2].set_ylim(bottom=.5)\n",
    "        #axarr[3].set_ylim(bottom=.5)\n",
    "        handles, labels = plt.gca().get_legend_handles_labels()\n",
    "        handles, labels = zip(*[ (handles[i], labels[i]) for i in sorted(range(len(handles)), key=lambda k: list(map(int,labels))[k])] )\n",
    "        labels = ['Width = '+label for label in labels]\n",
    "        plt.legend(handles, labels, bbox_to_anchor=(1.1,1.1))\n",
    "        for i, ax in enumerate(axarr): \n",
    "            ax.set_xlabel('SGD step')\n",
    "            ax.text(-0.1, 1.1, string.ascii_uppercase[i], transform=ax.transAxes, size=20, weight='bold')\n",
    "        axarr[0].set_ylabel('BP train error')\n",
    "        axarr[1].set_ylabel('DFA train error')\n",
    "        axarr[2].set_ylabel('WA last layer')\n",
    "        axarr[3].set_ylabel('GA last layer')\n",
    "    \n",
    "        print('{} {}'.format(args.dataset, args.activation))\n",
    "        plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
    "        plt.savefig(savedir+'Results_dynamics_{}_{}.pdf'.format(args.dataset, args.activation), bbox_inches='tight')\n",
    "        plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
